using AutoMapper;
using Microsoft.EntityFrameworkCore;
using UniversalAdmin.Application.DTOs;
using UniversalAdmin.Application.Services;
using UniversalAdmin.Domain.Entities;
using UniversalAdmin.Domain.Repositories;
using UniversalAdmin.Infrastructure.Data.Contexts;

namespace UniversalAdmin.Infrastructure.Services;

public class ChatService : IChatService
{
    private readonly IDocumentRepository _documentRepository;
    private readonly IDocumentChunkRepository _documentChunkRepository;
    private readonly IConversationRepository _conversationRepository;
    private readonly IMessageRepository _messageRepository;
    private readonly IEmbeddingService _embeddingService;
    private readonly IMapper _mapper;
    private readonly ApplicationDbContext _context;

    public ChatService(
        IDocumentRepository documentRepository,
        IDocumentChunkRepository documentChunkRepository,
        IConversationRepository conversationRepository,
        IMessageRepository messageRepository,
        IEmbeddingService embeddingService,
        IMapper mapper,
        ApplicationDbContext context)
    {
        _documentRepository = documentRepository;
        _documentChunkRepository = documentChunkRepository;
        _conversationRepository = conversationRepository;
        _messageRepository = messageRepository;
        _embeddingService = embeddingService;
        _mapper = mapper;
        _context = context;
    }

    public async Task<ChatResponseDto> GetAnswerAsync(Guid userId, Guid? conversationId, string question)
    {
        // 使用事务确保数据一致性
        using var transaction = await _context.Database.BeginTransactionAsync();

        try
        {
            // 如果没有提供对话ID，创建新的对话
            if (conversationId == null || conversationId == Guid.Empty)
            {
                var conversation = new Conversation
                {
                    UserId = userId,
                    Title = $"对话_{DateTime.Now:yyyyMMdd_HHmmss}",
                    CreatedAt = DateTime.UtcNow,
                    UpdatedAt = DateTime.UtcNow,
                    CreateBy = userId.ToString(),
                    UpdateBy = userId.ToString(),
                    IsActive = true,
                    IsDeleted = false,
                    RowVersion = Array.Empty<byte>()
                };

                await _context.Conversations.AddAsync(conversation);
                await _context.SaveChangesAsync();
                conversationId = conversation.Id;
            }

            // 生成查询的嵌入向量
            var queryEmbedding = await _embeddingService.GenerateEmbeddingAsync(question, true);

            // 检索相关的文档块
            var relevantChunks = await RetrieveRelevantChunksAsync(queryEmbedding, userId);

            // 构建上下文
            var context = BuildContext(relevantChunks);

            // 生成回答（这里需要集成具体的AI服务）
            var answer = await GenerateAnswerAsync(question, context);

            // 保存用户消息
            var userMessage = new Message
            {
                ConversationId = conversationId.Value,
                Role = "user",
                Content = question,
                CreatedAt = DateTime.UtcNow,
                UpdatedAt = DateTime.UtcNow,
                CreateBy = userId.ToString(),
                UpdateBy = userId.ToString(),
                IsActive = true,
                IsDeleted = false,
                RowVersion = Array.Empty<byte>()
            };
            await _context.Messages.AddAsync(userMessage);

            // 保存助手消息
            var assistantMessage = new Message
            {
                ConversationId = conversationId.Value,
                Role = "assistant",
                Content = answer,
                CreatedAt = DateTime.UtcNow,
                UpdatedAt = DateTime.UtcNow,
                CreateBy = userId.ToString(),
                UpdateBy = userId.ToString(),
                IsActive = true,
                IsDeleted = false,
                RowVersion = Array.Empty<byte>()
            };
            await _context.Messages.AddAsync(assistantMessage);

            // 保存所有更改
            await _context.SaveChangesAsync();

            // 提交事务
            await transaction.CommitAsync();

            // 构建响应
            var response = new ChatResponseDto
            {
                Answer = answer,
                ConversationId = conversationId.Value,
                Sources = relevantChunks.Select(chunk => new SourceDto
                {
                    Content = chunk.Content,
                    Source = chunk.Document?.Source ?? "Unknown",
                    Similarity = chunk.Embedding != null ? CalculateSimilarity(queryEmbedding, chunk.Embedding.ToArray()) : 0
                }).ToList()
            };

            return response;
        }
        catch (Exception)
        {
            // 回滚事务
            await transaction.RollbackAsync();
            throw;
        }
    }

    public async Task<List<MessageDto>> GetConversationHistoryAsync(Guid userId, Guid conversationId)
    {
        var messages = await _messageRepository.GetByConversationIdOrderedAsync(conversationId);
        var messageDtos = _mapper.Map<List<MessageDto>>(messages);

        // 为每个消息添加空的sources列表（历史消息可能没有保存sources信息）
        foreach (var messageDto in messageDtos)
        {
            messageDto.Sources = new List<SourceDto>();
        }

        return messageDtos;
    }

    public async Task<PagedResultDto<Conversation>> GetConversationsAsync(Guid userId, int page = 1, int pageSize = 10)
    {
        var query = _conversationRepository.GetQueryable()
            .Where(c => c.UserId == userId)
            .OrderByDescending(c => c.CreatedAt);

        var totalItems = await query.CountAsync();
        var items = await query
            .Skip((page - 1) * pageSize)
            .Take(pageSize)
            .ToListAsync();

        return new PagedResultDto<Conversation>
        {
            Items = items,
            TotalCount = totalItems,
            Page = page,
            PageSize = pageSize
        };
    }

    public async Task<Conversation> CreateConversationAsync(Guid userId, string title)
    {
        var conversation = new Conversation
        {
            UserId = userId,
            Title = title,
            CreatedAt = DateTime.UtcNow,
            UpdatedAt = DateTime.UtcNow,
            CreateBy = userId.ToString(),
            UpdateBy = userId.ToString(),
            IsActive = true,
            IsDeleted = false,
            RowVersion = Array.Empty<byte>()
        };

        return await _conversationRepository.AddAsync(conversation);
    }

    public async Task<bool> DeleteConversationAsync(Guid userId, Guid conversationId)
    {
        var conversation = await _conversationRepository.GetByIdAsync(conversationId);
        if (conversation == null || conversation.UserId != userId)
            return false;

        await _conversationRepository.DeleteAsync(conversation);
        return true;
    }

    private async Task<List<DocumentChunk>> RetrieveRelevantChunksAsync(float[] queryEmbedding, Guid userId)
    {
        // 获取用户的所有文档块
        var allChunks = await _documentChunkRepository.GetAllByUserIdAsync(userId);

        // 计算相似度并排序
        var chunksWithSimilarity = allChunks
            .Select(chunk => new
            {
                Chunk = chunk,
                Similarity = chunk.Embedding != null ? CalculateSimilarity(queryEmbedding, chunk.Embedding.ToArray()) : 0
            })
            .Where(x => x.Similarity > 0.3) // 相似度阈值（降低以提高召回率）
            .OrderByDescending(x => x.Similarity)
            .Take(5) // 取前5个最相关的块
            .ToList();

        return chunksWithSimilarity.Select(x => x.Chunk).ToList();
    }

    private string BuildContext(List<DocumentChunk> chunks)
    {
        return string.Join("\n\n", chunks.Select(chunk => chunk.Content));
    }

    private async Task<string> GenerateAnswerAsync(string question, string context)
    {
        try
        {
            // 如果有上下文，使用RAG方式回答
            if (!string.IsNullOrWhiteSpace(context))
            {
                var prompt = $@"请基于以下上下文信息回答用户的问题。如果上下文中没有相关信息，请诚实说明。

上下文信息：
{context}

用户问题：{question}

请提供准确、有用的回答：";

                // 这里可以集成具体的AI服务
                // 暂时使用智能的模拟回答
                return await GenerateSmartAnswerAsync(question, context, prompt);
            }
            else
            {
                // 没有相关文档时，判断问题类型
                return await GenerateGeneralAnswerAsync(question);
            }
        }
        catch (Exception ex)
        {
            return $"生成回答时出现错误：{ex.Message}";
        }
    }

    private async Task<string> GenerateGeneralAnswerAsync(string question)
    {
        // 对于通用问题，直接调用AI接口
        try
        {
            // 使用现有的嵌入服务配置来调用AI接口
            return await CallAIForGeneralQuestionAsync(question);
        }
        catch (Exception ex)
        {
            Console.WriteLine($"调用AI接口失败: {ex.Message}，使用本地智能回答");
            // 如果AI接口调用失败，使用本地智能回答作为后备
            return await GenerateLocalSmartAnswerAsync(question);
        }
    }

    private async Task<string> CallAIForGeneralQuestionAsync(string question)
    {
        // 构造对话请求
        var requestData = new
        {
            model = "qwen-turbo", // 使用配置中的模型
            messages = new[]
            {
                new
                {
                    role = "system",
                    content = "你是一个智能助手，可以回答各种问题。如果用户询问你的身份，请说你是基于RAG技术的AI助手，既能进行通用对话，也能基于用户上传的文档提供专业问答。请用中文回答，语言要友好、专业。"
                },
                new
                {
                    role = "user",
                    content = question
                }
            },
            max_tokens = 1000,
            temperature = 0.7
        };

        var json = System.Text.Json.JsonSerializer.Serialize(requestData);
        var content = new StringContent(json, System.Text.Encoding.UTF8, "application/json");

        // 使用Kimi的聊天接口
        var chatUrl = "https://dashscope.aliyuncs.com/compatible-mode/v1/chat/completions";

        using var httpClient = new HttpClient();
        httpClient.DefaultRequestHeaders.Add("Authorization", $"Bearer sk-7c86c36dda20476088d4cebd87c0300b");

        var response = await httpClient.PostAsync(chatUrl, content);
        var responseContent = await response.Content.ReadAsStringAsync();

        if (response.IsSuccessStatusCode)
        {
            var jsonResponse = System.Text.Json.JsonDocument.Parse(responseContent);
            var aiAnswer = jsonResponse.RootElement
                .GetProperty("choices")[0]
                .GetProperty("message")
                .GetProperty("content")
                .GetString();

            return aiAnswer ?? "抱歉，我现在无法回答这个问题。";
        }
        else
        {
            Console.WriteLine($"AI接口调用失败: {response.StatusCode}, {responseContent}");
            throw new Exception($"AI接口调用失败: {response.StatusCode}");
        }
    }

    private async Task<string> GenerateLocalSmartAnswerAsync(string question)
    {
        await Task.Delay(200); // 模拟处理时间

        var lowerQuestion = question.ToLower();

        // 通用问候和自我介绍
        if (lowerQuestion.Contains("你好") || lowerQuestion.Contains("hello") || lowerQuestion.Contains("hi"))
        {
            return "您好！我是您的AI助手。我可以帮您：\n" +
                   "1. 回答各种通用问题\n" +
                   "2. 基于您上传的文档提供专业问答\n" +
                   "3. 进行日常对话交流\n\n" +
                   "无论是否上传文档，我都能为您提供帮助！";
        }

        // 关于AI模型的问题
        if (lowerQuestion.Contains("什么模型") || lowerQuestion.Contains("ai模型") || lowerQuestion.Contains("你是什么"))
        {
            return "我是一个基于RAG（检索增强生成）技术的智能AI助手。我的特点：\n" +
                   "• 📖 **双模式服务**：既能回答通用问题，也能基于您的文档提供专业解答\n" +
                   "• 🧠 **智能理解**：具备上下文理解和对话记忆能力\n" +
                   "• 📚 **文档分析**：支持多种文档格式的智能分析\n" +
                   "• 🔍 **精准检索**：能快速定位相关信息并提供来源\n\n" +
                   "您可以直接与我对话，也可以上传文档获得更专业的回答！";
        }

        // 功能介绍
        if (lowerQuestion.Contains("能做什么") || lowerQuestion.Contains("功能") || lowerQuestion.Contains("怎么用"))
        {
            return "我为您提供全方位的AI助手服务：\n\n" +
                   "🤖 **通用对话**\n" +
                   "• 回答各种日常问题\n" +
                   "• 提供信息查询和建议\n" +
                   "• 进行自然语言交流\n\n" +
                   "📚 **文档问答**\n" +
                   "• 上传文档，基于内容精准回答\n" +
                   "• 智能分析长文档\n" +
                   "• 提供信息来源和相似度\n\n" +
                   "💬 **智能记忆**\n" +
                   "• 记住对话历史\n" +
                   "• 保持上下文连贯性\n" +
                   "• 个性化服务体验";
        }

        // 默认智能回答
        return $"关于\"{question}\"这个问题，我很乐意为您解答！\n\n" +
               "💡 **我可以：**\n" +
               "• 直接回答您的问题（通用知识）\n" +
               "• 如果您有相关文档，上传后我能提供更专业的回答\n" +
               "• 与您进行深入的对话交流\n\n" +
               "请告诉我更多细节，或者直接提出您想了解的具体内容！😊";
    }

    private async Task<string> GenerateSmartAnswerAsync(string question, string context, string prompt)
    {
        try
        {
            Console.WriteLine($"🚀 尝试调用AI服务...");
            Console.WriteLine($"🚀 问题: {question}");
            Console.WriteLine($"🚀 上下文: {context}");

            // 使用AI服务基于上下文生成智能回答
            var aiAnswer = await CallAIWithContextAsync(question, context);
            Console.WriteLine($"✅ AI服务返回答案: {aiAnswer?.Substring(0, Math.Min(100, aiAnswer?.Length ?? 0))}...");
            return aiAnswer ?? "抱歉，我现在无法基于文档内容回答这个问题。";
        }
        catch (Exception ex)
        {
            Console.WriteLine($"❌ AI服务调用失败: {ex.Message}");
            Console.WriteLine($"🔍 异常类型: {ex.GetType().Name}");
            Console.WriteLine($"📋 异常堆栈: {ex.StackTrace}");
            Console.WriteLine($"🔄 回退到本地智能回答...");
            // 如果AI服务调用失败，使用本地智能回答作为后备
            return await GenerateLocalSmartAnswerAsync(question, context);
        }
    }

    private async Task<string> CallAIWithContextAsync(string question, string context)
    {
        try
        {
            Console.WriteLine($"🔍 开始调用AI服务，问题: {question}");
            Console.WriteLine($"📚 上下文长度: {context?.Length ?? 0} 字符");

            // 构造带上下文的对话请求
            var requestData = new
            {
                model = "qwen-turbo",
                messages = new[]
                {
                                         new
                     {
                         role = "system",
                         content = "你是一个专业的RAG（检索增强生成）AI助手。你的任务是：\n\n" +
                                  "1. 智能理解问题：准确识别用户问题的真正意图和类型\n" +
                                  "2. 深度分析文档：基于上下文信息提供有洞察力的分析，而不是简单重复\n" +
                                  "3. 专业概念解释：当文档提到专业概念时，主动解释其含义、特征和分类\n" +
                                  "4. 类型识别能力：特别擅长识别和解释\"是什么类型\"、\"属于什么类别\"等问题\n" +
                                  "5. 结合通用知识：将文档信息与通用知识结合，提供教育意义的回答\n" +
                                  "6. 结构化回答：使用清晰的格式、emoji和要点来组织回答\n" +
                                  "7. 避免重复：不要简单重复文档内容，要进行分析、解释和总结\n\n" +
                                  "重要规则：\n" +
                                  "- 当用户问\"X是什么类型\"时，要主动分析X的特征，解释其所属类型的特点\n" +
                                  "- 当文档提到游戏、技术、商业等概念时，要结合常识进行专业解释\n" +
                                  "- 回答要有逻辑性、教育性和实用性\n" +
                                  "- 使用中文回答，语言要友好、专业、易懂\n\n" +
                                  "关键能力：\n" +
                                  "- 能够从文档中提取关键信息（如游戏类型、技术分类等）\n" +
                                  "- 能够结合通用知识解释专业概念\n" +
                                  "- 能够识别问题的真正意图并提供有价值的回答"
                     },
                                         new
                     {
                         role = "user",
                         content = "基于以下上下文信息，请智能分析并回答用户问题。\n\n" +
                                  "上下文信息：\n" +
                                  context + "\n\n" +
                                  "用户问题：\n" +
                                  question + "\n\n" +
                                  "回答要求：\n" +
                                  "1. 智能分析：不要简单重复文档内容，要进行分析和解释\n" +
                                  "2. 类型识别：如果用户问\"是什么类型\"，要主动分析特征并解释该类型的特点\n" +
                                  "3. 专业解释：结合通用知识解释专业概念，让回答更有教育意义\n" +
                                  "4. 结构化：使用清晰的格式和要点组织回答\n" +
                                  "5. 实用性：提供有实际价值的信息和建议\n\n" +
                                  "特别说明：\n" +
                                  "- 如果文档中提到\"X大逃杀游戏\"，说明X属于大逃杀游戏类型\n" +
                                  "- 如果文档中提到\"X RPG游戏\"，说明X属于角色扮演游戏类型\n" +
                                  "- 如果文档中提到\"X FPS游戏\"，说明X属于第一人称射击游戏类型\n" +
                                  "- 要主动解释这些游戏类型的特点和特征\n\n" +
                                  "请基于文档内容，结合通用知识，提供专业、准确、有教育意义的回答："
                     }
                },
                max_tokens = 2000,
                temperature = 0.1 // 降低温度以获得更准确、一致的回答
            };

            var json = System.Text.Json.JsonSerializer.Serialize(requestData);
            var content = new StringContent(json, System.Text.Encoding.UTF8, "application/json");

            Console.WriteLine($"🌐 请求URL: https://dashscope.aliyuncs.com/compatible-mode/v1/chat/completions");
            Console.WriteLine($"🔑 使用API密钥: sk-7c86c36dda20476088d4cebd87c0300b");

            // 使用Kimi的聊天接口
            var chatUrl = "https://dashscope.aliyuncs.com/compatible-mode/v1/chat/completions";

            using var httpClient = new HttpClient();
            httpClient.Timeout = TimeSpan.FromSeconds(30); // 设置30秒超时
            httpClient.DefaultRequestHeaders.Add("Authorization", $"Bearer sk-7c86c36dda20476088d4cebd87c0300b");

            Console.WriteLine("📤 发送请求到AI服务...");
            var response = await httpClient.PostAsync(chatUrl, content);
            var responseContent = await response.Content.ReadAsStringAsync();

            Console.WriteLine($"📥 收到响应: {response.StatusCode}");
            Console.WriteLine($"📄 响应内容长度: {responseContent?.Length ?? 0} 字符");

            if (response.IsSuccessStatusCode)
            {
                Console.WriteLine("✅ AI服务调用成功，解析响应...");
                if (string.IsNullOrEmpty(responseContent))
                {
                    throw new Exception("AI服务返回了空的响应内容");
                }
                var jsonResponse = System.Text.Json.JsonDocument.Parse(responseContent);
                var aiAnswer = jsonResponse.RootElement
                    .GetProperty("choices")[0]
                    .GetProperty("message")
                    .GetProperty("content")
                    .GetString();

                Console.WriteLine($"🤖 AI回答长度: {aiAnswer?.Length ?? 0} 字符");
                return aiAnswer ?? "抱歉，我现在无法基于文档内容回答这个问题。";
            }
            else
            {
                Console.WriteLine($"❌ AI接口调用失败: {response.StatusCode}");
                Console.WriteLine($"📄 错误响应内容: {responseContent}");
                throw new Exception($"AI接口调用失败: {response.StatusCode} - {responseContent}");
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"💥 AI服务调用异常: {ex.GetType().Name}: {ex.Message}");
            if (ex.InnerException != null)
            {
                Console.WriteLine($"🔍 内部异常: {ex.InnerException.Message}");
            }
            throw;
        }
    }

    private async Task<string> GenerateLocalSmartAnswerAsync(string question, string context)
    {
        // 本地智能回答作为后备方案
        await Task.Delay(200);

        Console.WriteLine($"🔄 本地智能回答 - 问题: {question}");
        Console.WriteLine($"🔄 本地智能回答 - 上下文: {context}");

        // 智能分析问题和上下文
        var analysis = AnalyzeQuestionAndContext(question, context);
        Console.WriteLine($"🧠 智能分析结果: {analysis.AnalysisType}");
        Console.WriteLine($"🎯 目标概念: {analysis.TargetConcept}");
        Console.WriteLine($"🏷️ 上下文类型: {analysis.ContextType}");

        // 根据分析结果生成相应的回答
        switch (analysis.AnalysisType)
        {
            case QuestionAnalysisType.TypeDefinition:
                return GenerateTypeDefinitionAnswer(question, context, analysis);
            case QuestionAnalysisType.Comparison:
                return GenerateComparisonAnswer(question, context, analysis);
            case QuestionAnalysisType.Explanation:
                return GenerateExplanationAnswer(question, context, analysis);
            case QuestionAnalysisType.Summary:
                return GenerateSummaryAnswer(question, context, analysis);
            case QuestionAnalysisType.Procedure:
                return GenerateProcedureAnswer(question, context, analysis);
            default:
                return GenerateGeneralAnswer(question, context, analysis);
        }
    }

    private QuestionAnalysis AnalyzeQuestionAndContext(string question, string context)
    {
        var lowerQuestion = question.ToLower();
        var analysis = new QuestionAnalysis
        {
            Question = question,
            Context = context,
            Keywords = ExtractKeywords(question),
            ContextKeywords = ExtractKeywords(context)
        };

        // 分析问题类型
        if (IsTypeQuestion(lowerQuestion))
        {
            analysis.AnalysisType = QuestionAnalysisType.TypeDefinition;
            analysis.TargetConcept = ExtractTargetConcept(lowerQuestion);
        }
        else if (IsComparisonQuestion(lowerQuestion))
        {
            analysis.AnalysisType = QuestionAnalysisType.Comparison;
            analysis.ComparisonItems = ExtractComparisonItems(lowerQuestion);
        }
        else if (IsExplanationQuestion(lowerQuestion))
        {
            analysis.AnalysisType = QuestionAnalysisType.Explanation;
            analysis.TargetConcept = ExtractTargetConcept(lowerQuestion);
        }
        else if (IsSummaryQuestion(lowerQuestion))
        {
            analysis.AnalysisType = QuestionAnalysisType.Summary;
        }
        else if (IsProcedureQuestion(lowerQuestion))
        {
            analysis.AnalysisType = QuestionAnalysisType.Procedure;
            analysis.TargetConcept = ExtractTargetConcept(lowerQuestion);
        }
        else
        {
            analysis.AnalysisType = QuestionAnalysisType.General;
        }

        // 分析上下文内容
        analysis.ContextType = AnalyzeContextType(context);
        analysis.KeyInformation = ExtractKeyInformation(context);

        return analysis;
    }

    private bool IsTypeQuestion(string lowerQuestion)
    {
        return lowerQuestion.Contains("是什么类型") ||
               lowerQuestion.Contains("什么类型") ||
               lowerQuestion.Contains("类型") ||
               lowerQuestion.Contains("属于") ||
               lowerQuestion.Contains("分类") ||
               lowerQuestion.Contains("范畴") ||
               lowerQuestion.Contains("游戏"); // 添加游戏关键词识别
    }

    private bool IsComparisonQuestion(string lowerQuestion)
    {
        return lowerQuestion.Contains("比较") ||
               lowerQuestion.Contains("区别") ||
               lowerQuestion.Contains("差异") ||
               lowerQuestion.Contains("vs") ||
               lowerQuestion.Contains("对比");
    }

    private bool IsExplanationQuestion(string lowerQuestion)
    {
        return lowerQuestion.Contains("解释") ||
               lowerQuestion.Contains("说明") ||
               lowerQuestion.Contains("什么是") ||
               lowerQuestion.Contains("如何") ||
               lowerQuestion.Contains("为什么");
    }

    private bool IsSummaryQuestion(string lowerQuestion)
    {
        return lowerQuestion.Contains("总结") ||
               lowerQuestion.Contains("概括") ||
               lowerQuestion.Contains("概述") ||
               lowerQuestion.Contains("主要内容");
    }

    private bool IsProcedureQuestion(string lowerQuestion)
    {
        return lowerQuestion.Contains("步骤") ||
               lowerQuestion.Contains("流程") ||
               lowerQuestion.Contains("方法") ||
               lowerQuestion.Contains("怎么做") ||
               lowerQuestion.Contains("如何实现");
    }

    private string ExtractTargetConcept(string question)
    {
        // 提取问题中的目标概念
        var patterns = new[]
        {
            @"(.*?)是什么类型",
            @"(.*?)什么类型",
            @"(.*?)属于",
            @"(.*?)分类",
            @"什么是(.*?)",
            @"解释(.*?)",
            @"说明(.*?)"
        };

        foreach (var pattern in patterns)
        {
            var match = System.Text.RegularExpressions.Regex.Match(question, pattern);
            if (match.Success && match.Groups.Count > 1)
            {
                return match.Groups[1].Value.Trim();
            }
        }

        return string.Empty;
    }

    private List<string> ExtractComparisonItems(string question)
    {
        // 提取比较项目
        var items = new List<string>();
        // 这里可以实现更复杂的比较项目提取逻辑
        return items;
    }

    private ContextType AnalyzeContextType(string context)
    {
        var lowerContext = context.ToLower();

        if (lowerContext.Contains("游戏") || lowerContext.Contains("game"))
            return ContextType.Gaming;
        if (lowerContext.Contains("技术") || lowerContext.Contains("tech") || lowerContext.Contains("编程"))
            return ContextType.Technology;
        if (lowerContext.Contains("商业") || lowerContext.Contains("business") || lowerContext.Contains("公司"))
            return ContextType.Business;
        if (lowerContext.Contains("教育") || lowerContext.Contains("education") || lowerContext.Contains("学习"))
            return ContextType.Education;
        if (lowerContext.Contains("健康") || lowerContext.Contains("health") || lowerContext.Contains("医疗"))
            return ContextType.Health;

        return ContextType.General;
    }

    private List<string> ExtractKeyInformation(string context)
    {
        var sentences = context.Split(new[] { '。', '.', '\n', '！', '？' }, StringSplitOptions.RemoveEmptyEntries);
        var keyInfo = new List<string>();

        foreach (var sentence in sentences)
        {
            var trimmed = sentence.Trim();
            if (trimmed.Length > 10 && trimmed.Length < 200) // 过滤太短或太长的句子
            {
                keyInfo.Add(trimmed);
            }
        }

        return keyInfo.Take(5).ToList(); // 最多取5个关键信息
    }

    private string GenerateTypeDefinitionAnswer(string question, string context, QuestionAnalysis analysis)
    {
        var targetConcept = analysis.TargetConcept;
        var contextType = analysis.ContextType;

        // 根据上下文类型生成相应的类型定义
        switch (contextType)
        {
            case ContextType.Gaming:
                return GenerateGamingTypeDefinition(targetConcept, context, analysis);
            case ContextType.Technology:
                return GenerateTechnologyTypeDefinition(targetConcept, context, analysis);
            case ContextType.Business:
                return GenerateBusinessTypeDefinition(targetConcept, context, analysis);
            case ContextType.Education:
                return GenerateEducationTypeDefinition(targetConcept, context, analysis);
            case ContextType.Health:
                return GenerateHealthTypeDefinition(targetConcept, context, analysis);
            default:
                return GenerateGenericTypeDefinition(targetConcept, context, analysis);
        }
    }

    private string GenerateGamingTypeDefinition(string targetConcept, string context, QuestionAnalysis analysis)
    {
        // 游戏类型定义生成
        var gameTypes = new Dictionary<string, string>
        {
            {"大逃杀", "大逃杀（Battle Royale）是一种多人在线竞技游戏类型，具有生存竞争、资源收集、安全区域收缩等特点"},
            {"rpg", "RPG（角色扮演游戏）是一种让玩家扮演特定角色，通过完成任务和升级来推进剧情的游戏类型"},
            {"fps", "FPS（第一人称射击游戏）是一种以第一人称视角进行的射击游戏，强调反应速度和战术思维"},
            {"moba", "MOBA（多人在线战术竞技游戏）是一种团队合作的策略游戏，需要配合和战术规划"},
            {"沙盒", "沙盒游戏是一种开放世界游戏，玩家可以自由探索和创造，没有固定的游戏目标"}
        };

        foreach (var gameType in gameTypes)
        {
            if (context.ToLower().Contains(gameType.Key.ToLower()) ||
                targetConcept.ToLower().Contains(gameType.Key.ToLower()))
            {
                return $@"根据您的文档内容，{targetConcept}属于{gameType.Key}类型。

🎮 **{gameType.Key}游戏类型详细说明：**
{gameType.Value}

**主要特点：**
• **游戏机制**：具有独特的游戏玩法和规则
• **玩家体验**：提供沉浸式的游戏体验
• **策略性**：需要战术思维和团队配合
• **竞技性**：强调玩家技能和策略运用

**知名游戏示例：**
- 大逃杀：PUBG、Fortnite、Apex Legends
- RPG：最终幻想、巫师、上古卷轴
- FPS：使命召唤、战地、CS:GO
- MOBA：英雄联盟、Dota 2
- 沙盒：我的世界、GTA、塞尔达传说

您的文档提到的{targetConcept}正是这类游戏的典型代表！";
            }
        }

        // 如果没有找到预定义类型，生成通用回答
        return GenerateGenericTypeDefinition(targetConcept, context, analysis);
    }

    private string GenerateTechnologyTypeDefinition(string targetConcept, string context, QuestionAnalysis analysis)
    {
        // 技术类型定义生成
        var techTypes = new Dictionary<string, string>
        {
            {"编程语言", "编程语言是用于编写计算机程序的形式化语言，具有特定的语法和语义规则"},
            {"框架", "框架是提供基础功能和支持的软件架构，开发者可以在此基础上构建应用程序"},
            {"数据库", "数据库是结构化信息的集合，用于存储、管理和检索数据"},
            {"算法", "算法是解决特定问题的一系列步骤或规则，是计算机科学的核心概念"},
            {"架构", "软件架构是系统的高级结构，定义了组件之间的关系和交互方式"}
        };

        foreach (var techType in techTypes)
        {
            if (context.ToLower().Contains(techType.Key.ToLower()) ||
                targetConcept.ToLower().Contains(techType.Key.ToLower()))
            {
                return $@"根据您的文档内容，{targetConcept}属于{techType.Key}。

💻 **{techType.Key}详细说明：**
{techType.Value}

**技术特点：**
• **功能性**：提供特定的技术能力
• **标准化**：遵循行业标准和规范
• **可扩展性**：支持功能扩展和定制
• **兼容性**：与其他技术组件协同工作

**应用场景：**
- 软件开发
- 系统设计
- 问题解决
- 性能优化

您的文档提到的{targetConcept}正是这类技术的典型应用！";
            }
        }

        return GenerateGenericTypeDefinition(targetConcept, context, analysis);
    }

    private string GenerateBusinessTypeDefinition(string targetConcept, string context, QuestionAnalysis analysis)
    {
        // 商业类型定义生成
        var businessTypes = new Dictionary<string, string>
        {
            {"商业模式", "商业模式是描述企业如何创造、传递和获取价值的方式"},
            {"营销策略", "营销策略是企业为实现营销目标而制定的计划和方案"},
            {"财务管理", "财务管理是对企业财务活动进行规划、组织、协调和控制的过程"},
            {"人力资源", "人力资源管理是对企业人力资源进行规划、招聘、培训和管理的过程"},
            {"供应链", "供应链是产品从原材料到最终消费者的整个流程网络"}
        };

        foreach (var businessType in businessTypes)
        {
            if (context.ToLower().Contains(businessType.Key.ToLower()) ||
                targetConcept.ToLower().Contains(businessType.Key.ToLower()))
            {
                return $@"根据您的文档内容，{targetConcept}属于{businessType.Key}。

💼 **{businessType.Key}详细说明：**
{businessType.Value}

**商业特点：**
• **价值创造**：为客户创造实际价值
• **可持续性**：确保长期盈利能力
• **市场导向**：以市场需求为导向
• **创新性**：持续创新和改进

**应用领域：**
- 企业战略规划
- 市场分析
- 运营管理
- 客户服务

您的文档提到的{targetConcept}正是这类商业概念的典型应用！";
            }
        }

        return GenerateGenericTypeDefinition(targetConcept, context, analysis);
    }

    private string GenerateEducationTypeDefinition(string targetConcept, string context, QuestionAnalysis analysis)
    {
        // 教育类型定义生成
        var educationTypes = new Dictionary<string, string>
        {
            {"教学方法", "教学方法是教师在教学过程中采用的具体方式和手段"},
            {"学习策略", "学习策略是学习者为达到学习目标而采用的方法和技巧"},
            {"课程设计", "课程设计是对教学内容和活动进行规划和组织的过程"},
            {"评估方法", "评估方法是衡量学生学习成果和教学效果的工具和手段"},
            {"教育技术", "教育技术是将技术手段应用于教育过程的实践"}
        };

        foreach (var educationType in educationTypes)
        {
            if (context.ToLower().Contains(educationType.Key.ToLower()) ||
                targetConcept.ToLower().Contains(educationType.Key.ToLower()))
            {
                return $@"根据您的文档内容，{targetConcept}属于{educationType.Key}。

📚 **{educationType.Key}详细说明：**
{educationType.Value}

**教育特点：**
• **目标导向**：以学习目标为导向
• **个性化**：适应不同学习者的需求
• **互动性**：促进师生和生生互动
• **有效性**：确保教学效果和学习成果

**应用场景：**
- 课堂教学
- 在线学习
- 培训项目
- 教育评估

您的文档提到的{targetConcept}正是这类教育概念的典型应用！";
            }
        }

        return GenerateGenericTypeDefinition(targetConcept, context, analysis);
    }

    private string GenerateHealthTypeDefinition(string targetConcept, string context, QuestionAnalysis analysis)
    {
        // 健康类型定义生成
        var healthTypes = new Dictionary<string, string>
        {
            {"疾病类型", "疾病类型是根据病因、症状和病理变化对疾病进行的分类"},
            {"治疗方法", "治疗方法是针对特定疾病或症状采取的医疗干预措施"},
            {"预防措施", "预防措施是为防止疾病发生而采取的健康保护行动"},
            {"营养方案", "营养方案是根据个体需求制定的饮食和营养补充计划"},
            {"康复训练", "康复训练是帮助患者恢复身体功能的系统性训练"}
        };

        foreach (var healthType in healthTypes)
        {
            if (context.ToLower().Contains(healthType.Key.ToLower()) ||
                targetConcept.ToLower().Contains(healthType.Key.ToLower()))
            {
                return $@"根据您的文档内容，{targetConcept}属于{healthType.Key}。

🏥 **{healthType.Key}详细说明：**
{healthType.Value}

**健康特点：**
• **科学性**：基于医学科学原理
• **个性化**：根据个体情况定制
• **安全性**：确保治疗和预防的安全
• **有效性**：经过验证的医疗效果

**应用领域：**
- 临床治疗
- 健康管理
- 疾病预防
- 康复护理

您的文档提到的{targetConcept}正是这类健康概念的典型应用！";
            }
        }

        return GenerateGenericTypeDefinition(targetConcept, context, analysis);
    }

    private string GenerateGenericTypeDefinition(string targetConcept, string context, QuestionAnalysis analysis)
    {
        // 通用类型定义生成
        var keyInfo = string.Join("\n• ", analysis.KeyInformation.Take(3));

        return $@"根据您的文档内容，我找到了关于{targetConcept}的相关信息。

📚 **文档内容分析：**
• {keyInfo}

🔍 **类型识别：**
基于文档内容，{targetConcept}具有以下特征：
• 在您的文档中有明确提及
• 具有特定的属性和特点
• 属于某个特定的分类或范畴

💡 **建议：**
为了更好地理解{targetConcept}的类型和特点，建议：
1. 查看完整文档获取更多细节
2. 结合上下文理解其具体含义
3. 如果需要更专业的分类，可以使用AI服务进行深入分析

您的文档为理解{targetConcept}提供了重要信息！";
    }

    private string GenerateComparisonAnswer(string question, string context, QuestionAnalysis analysis)
    {
        // 比较类问题的回答生成
        return $@"根据您的文档内容，我来帮您分析比较相关的问题。

📊 **比较分析：**
基于文档中的信息，我发现了以下关键点：
{string.Join("\n• ", analysis.KeyInformation.Take(3))}

🔍 **分析建议：**
为了提供更准确的比较分析，建议：
1. 明确比较的具体维度
2. 提供更多相关的对比信息
3. 使用AI服务进行深入分析

您的文档为比较分析提供了基础信息！";
    }

    private string GenerateExplanationAnswer(string question, string context, QuestionAnalysis analysis)
    {
        // 解释类问题的回答生成
        var targetConcept = analysis.TargetConcept;
        var keyInfo = string.Join("\n• ", analysis.KeyInformation.Take(3));

        return $@"根据您的文档内容，我来解释{targetConcept}。

📖 **概念解释：**
基于文档信息，{targetConcept}具有以下特点：
• {keyInfo}

💡 **深入理解：**
为了更好地理解{targetConcept}，建议：
1. 结合文档上下文理解其含义
2. 关注相关的属性和特征
3. 使用AI服务获取更专业的解释

您的文档为理解{targetConcept}提供了重要基础！";
    }

    private string GenerateSummaryAnswer(string question, string context, QuestionAnalysis analysis)
    {
        // 总结类问题的回答生成
        var keyInfo = string.Join("\n• ", analysis.KeyInformation);

        return $@"根据您的文档内容，我来为您总结主要内容。

📋 **内容总结：**
{keyInfo}

🎯 **关键要点：**
• 文档包含了{analysis.KeyInformation.Count}个主要信息点
• 内容涉及{analysis.ContextType}领域
• 提供了具体的信息和说明

💡 **总结建议：**
为了获得更全面的总结，建议：
1. 查看完整文档内容
2. 关注信息的逻辑关系
3. 使用AI服务进行深度分析

您的文档内容丰富且有意义！";
    }

    private string GenerateProcedureAnswer(string question, string context, QuestionAnalysis analysis)
    {
        // 流程类问题的回答生成
        var targetConcept = analysis.TargetConcept;
        var keyInfo = string.Join("\n• ", analysis.KeyInformation.Take(3));

        return $@"根据您的文档内容，我来解释{targetConcept}的相关流程。

🔄 **流程说明：**
基于文档信息，{targetConcept}涉及以下步骤：
• {keyInfo}

📋 **操作建议：**
为了更好地理解{targetConcept}的流程，建议：
1. 仔细阅读文档中的步骤说明
2. 注意操作顺序和注意事项
3. 使用AI服务获取更详细的指导

您的文档为理解{targetConcept}的流程提供了重要信息！";
    }

    private string GenerateGeneralAnswer(string question, string context, QuestionAnalysis analysis)
    {
        // 通用问题的回答生成
        var keyInfo = string.Join("\n• ", analysis.KeyInformation.Take(3));

        return $@"根据您的文档内容，我找到了相关信息来回答您的问题。

📚 **相关信息：**
• {keyInfo}

🔍 **回答分析：**
基于文档内容，我可以为您提供：
• 文档中明确提及的信息
• 相关的上下文内容
• 基于内容的初步分析

💡 **建议：**
为了获得更准确和深入的回答，建议：
1. 使用AI服务进行智能分析
2. 结合通用知识进行理解
3. 查看完整文档获取更多细节

您的文档为回答问题提供了重要参考！";
    }

    private List<string> ExtractKeywords(string text)
    {
        if (string.IsNullOrWhiteSpace(text)) return new List<string>();

        return text.Split(new[] { ' ', '\n', '\r', '\t', '，', '。', '？', '！', ',', '.', '?', '!' },
                         StringSplitOptions.RemoveEmptyEntries)
                  .Where(w => w.Length > 1)
                  .Take(10)
                  .ToList();
    }

    private string FindRelevantInformation(string context, List<string> questionKeywords)
    {
        var sentences = context.Split(new[] { '。', '.', '\n' }, StringSplitOptions.RemoveEmptyEntries);

        foreach (var sentence in sentences)
        {
            if (questionKeywords.Any(keyword => sentence.Contains(keyword, StringComparison.OrdinalIgnoreCase)))
            {
                return sentence.Trim();
            }
        }

        return string.Empty;
    }

    private double CalculateSimilarity(float[] embedding1, float[] embedding2)
    {
        if (embedding1.Length != embedding2.Length)
            return 0;

        var dotProduct = 0.0;
        var norm1 = 0.0;
        var norm2 = 0.0;

        for (int i = 0; i < embedding1.Length; i++)
        {
            dotProduct += embedding1[i] * embedding2[i];
            norm1 += embedding1[i] * embedding1[i];
            norm2 += embedding2[i] * embedding2[i];
        }

        return dotProduct / (Math.Sqrt(norm1) * Math.Sqrt(norm2));
    }
}

// 问题分析数据结构
public class QuestionAnalysis
{
    public string Question { get; set; } = string.Empty;
    public string Context { get; set; } = string.Empty;
    public List<string> Keywords { get; set; } = new List<string>();
    public List<string> ContextKeywords { get; set; } = new List<string>();
    public QuestionAnalysisType AnalysisType { get; set; }
    public string TargetConcept { get; set; } = string.Empty;
    public List<string> ComparisonItems { get; set; } = new List<string>();
    public ContextType ContextType { get; set; }
    public List<string> KeyInformation { get; set; } = new List<string>();
}

// 问题分析类型枚举
public enum QuestionAnalysisType
{
    TypeDefinition,    // 类型定义
    Comparison,        // 比较分析
    Explanation,       // 解释说明
    Summary,          // 总结概括
    Procedure,        // 流程步骤
    General           // 通用问题
}

// 上下文类型枚举
public enum ContextType
{
    Gaming,           // 游戏
    Technology,       // 技术
    Business,         // 商业
    Education,        // 教育
    Health,           // 健康
    General           // 通用
}